package com.example.demo;


import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.URLUtil;
import com.drew.imaging.ImageProcessingException;
import com.drew.imaging.jpeg.JpegMetadataReader;
import com.drew.imaging.jpeg.JpegProcessingException;
import com.drew.metadata.Directory;
import com.drew.metadata.Metadata;
import com.drew.metadata.MetadataException;
import com.drew.metadata.Tag;
import com.drew.metadata.exif.ExifDirectoryBase;
import lombok.extern.slf4j.Slf4j;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import java.awt.*;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.io.*;
import java.net.URL;


/**
 * 类描述信息
 *
 * @author TongDaShuai
 * @since 2021/10/15
 */
@Slf4j
public class ImageUtil {

    // 图片压缩质量顺序数组，数组下标对应压缩质量等级
    private static final float[] QUALITIES = new float[]{
            0.7F, 0.6F, 0.5F, 0.4F, 0.3F, 0.2F, 0.1F, 0.09F, 0.08F, 0.07F, 0.06F, 0.05F, 0.04F, 0.03F, 0.02F, 0.01F
    };

    /**
     * 默认的水印字体名称
     */
    public static final String DEFAULT_PRESS_TEXT_FONT_NAME = "微软雅黑";

    /**
     * 默认的水印字体类型
     */
    public static final int DEFAULT_PRESS_TEXT_FONT_TYPE = Font.PLAIN;

    /**
     * 默认的水印字体大小
     */
    public static final int DEFAULT_PRESS_TEXT_FONT_SIZE = 13;

    /**
     * 默认的水印字体颜色
     */
    public static final Color DEFAULT_PRESS_TEXT_FONT_COLOR = Color.BLACK;

    /**
     * 默认的描边大小
     */
    public static final float DEFAULT_STROKE_SIZE = 2f;

    /**
     * 默认的描边自适应比率
     */
    public static final float DEFAULT_STROKE_ADAPTIVE_RATIO = 0.2f;

    /**
     * 默认的描边颜色
     */
    public static final Color DEFAULT_PRESS_TEXT_STROKE_COLOR = Color.WHITE;




    /**
     * 压缩图片，不改变尺寸，降低分辨率
     *
     * @param source 源图片字节数组
     * @param quality 压缩质量，0-1
     * @return
     * @throws IOException
     */
    public static byte[] compress(byte[] source, float quality) {
        try(
            ByteArrayInputStream inputStream = new ByteArrayInputStream(source);
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream(source.length);
        ) {
            Image img = ImageIO.read(inputStream);

            if (img.getHeight(null) > 5000 || img.getWidth(null) > 5000) {
                throw new RuntimeException("图片太大了");
            }

            // 创建缓冲图像
            BufferedImage bufferedImage = new BufferedImage(img.getWidth(null),
                    img.getHeight(null), BufferedImage.TYPE_INT_RGB);

            // 将图像复制到缓冲图像
            Graphics g = bufferedImage.createGraphics();

            // 清除背景并绘制图像。
            g.setColor(Color.white);
            g.fillRect(0, 0, img.getWidth(null), img.getHeight(null));
            g.drawImage(img, 0, 0, null);
            g.dispose();

            float softenFactor = 0.05f;
            float[] softenArray = {0, softenFactor, 0, softenFactor, 1 - (softenFactor * 4), softenFactor, 0, softenFactor, 0};
            Kernel kernel = new Kernel(3, 3, softenArray);
            ConvolveOp cOp = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
            bufferedImage = cOp.filter(bufferedImage, null);


            // 将图像编码为jpeg数据流
            ImageWriter jpgWriter = ImageIO.getImageWritersByFormatName("jpg").next();
            ImageWriteParam jpgWriteParam = jpgWriter.getDefaultWriteParam();
            jpgWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            jpgWriteParam.setCompressionQuality(quality);

            jpgWriter.setOutput(ImageIO.createImageOutputStream(outputStream));
            IIOImage outputImage = new IIOImage(bufferedImage, null, null);
            jpgWriter.write(null, outputImage, jpgWriteParam);
            jpgWriter.dispose();

            /*JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(outputStream);

            JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bufferedImage);

            param.setQuality(quality, true);

            encoder.setJPEGEncodeParam(param);
            encoder.encode(bufferedImage);*/

            return outputStream.toByteArray();
        } catch (Exception e) {
            log.error("图片压缩失败", e);
            throw new RuntimeException("图片压缩失败");
        }
    }

    /**
     * 压缩图片到指定尺寸
     *
     * @param source 图片字节数组
     * @param size 指定大小，单位kb
     * @return
     */
    public static byte[] compress(byte[] source, int size) {
        int qualityLevel = 0;
        if (source.length <= size * 1024) {
            return ArrayUtil.clone(source);
        }
        while (true) {
            byte[] clone = ArrayUtil.clone(source);
            // 获取压缩质量
            float quality = getCompressQuality(qualityLevel++);
            byte[] compressed = compress(clone, quality);
            if (compressed.length <= size * 1024) {
                return compressed;
            }
        }
    }

    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressTexts 文字数组，分行打印
     * @param source 源图片字节数组
     * @param fontName  字体名
     * @param fontStyle 字体样式
     * @param color     字体颜色
     * @param fontSize  字体大小
     * @param x         偏移量
     * @param y         偏移量
     * @param fontAdaptive 是否字体大小自适应
     * @param fontAdaptiveRatio  字体大小自适应比例。如果fontAdaptive=true，那么fontSize失效，实际fontsize=图片宽度*fontAdaptiveRatio
     * @param minFontSize 字体大小自适应的最小字体大小
     * @param stroke 是否描边
     * @param strokeSize 描边大小
     * @param strokeAdaptive 是否描边大小自适应。如果strokeAdaptivetrue，那么strokeSize失效，实际strokeSize=字体大小*strokeAdaptiveRatio
     * @param strokeAdaptiveRatio  描边大小自适应比率（相对于字体大小）
     * @param strokeColor 描边颜色
     * @return 生成水印后的字节数组
     */
    public static byte[] pressText(String[] pressTexts, byte[] source, String fontName, int fontStyle, Color color,
                                   int fontSize, int x, int y, boolean fontAdaptive, float fontAdaptiveRatio, Integer minFontSize,
                                   boolean stroke, float strokeSize, boolean strokeAdaptive, float strokeAdaptiveRatio, Color strokeColor) throws IOException {
        try(
                ByteArrayInputStream inputStream = new ByteArrayInputStream(source);
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream(source.length);
        )
        {
            Image src = ImageIO.read(inputStream);
            int width = src.getWidth(null);
            int height = src.getHeight(null);

            // 创建缓冲图像
            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            // 将图像复制到缓冲图像
            Graphics2D g = image.createGraphics();
            g.drawImage(src, 0, 0, width, height, null);
            g.setColor(color);
            // 字体大小自适应
            if (fontAdaptive) {
                fontSize = (int) (width * fontAdaptiveRatio);
                // 最小自适应字体大小
                if (minFontSize != null && fontSize < minFontSize) {
                    fontSize = minFontSize;
                }
//                log.debug("width:" + width);
//                log.debug("fontAdaptiveRatio:" + fontAdaptiveRatio);
//                log.debug("实际fontSize：" + fontSize);
            }
            g.setFont(new Font(fontName, fontStyle, fontSize));
            for (int i = 0; i < pressTexts.length; i++) {
                if (stroke) {
                    // 描边处理
                    strokeSize = strokeAdaptive ? fontSize * strokeAdaptiveRatio : strokeSize;
                    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                    g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
                    g.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
                    FontRenderContext frc = g.getFontRenderContext();
                    TextLayout tl = new TextLayout(pressTexts[i], new Font(fontName, fontStyle, fontSize), frc);
                    // 文字坐标
                    Shape sha = tl.getOutline(AffineTransform.getTranslateInstance(x,y + fontSize * (i + 1)));
                    // 描边
                    g.setStroke(new BasicStroke(strokeSize));
                    // 描边颜色
                    g.setColor(strokeColor);
                    g.draw(sha);
                    g.setColor(color);
                    g.fill(sha);
                } else {
                    g.drawString(pressTexts[i], x, y + fontSize * (i + 1));
                }
            }

            g.dispose();

            // com.sun包不推荐使用，部分jdk版本可能不支持
//            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(outputStream);
//            encoder.encode(image);

            ImageIO.write(image, "jpg", outputStream);

            return outputStream.toByteArray();
        }
    }


    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressTexts 文字数组，分行打印
     * @param source 源图片字节数组
     * @param fontAdaptiveRatio  字体自适应比例。如果fontAdaptive=true，那么fontSize失效，实际fontsize=图片宽度*fontAdaptiveRatio
     * @param minFontSize 字体大小自适应的最小字体大小
     * @return 生成水印后的字节数组
     */
    public static byte[] pressText(String[] pressTexts, byte[] source, float fontAdaptiveRatio, Integer minFontSize) throws IOException {
        return pressText(pressTexts, source, DEFAULT_PRESS_TEXT_FONT_NAME, DEFAULT_PRESS_TEXT_FONT_TYPE,
                DEFAULT_PRESS_TEXT_FONT_COLOR, DEFAULT_PRESS_TEXT_FONT_SIZE, 0, 0, true, fontAdaptiveRatio,
                minFontSize, true, DEFAULT_STROKE_SIZE, true, DEFAULT_STROKE_ADAPTIVE_RATIO, DEFAULT_PRESS_TEXT_STROKE_COLOR);
    }

    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressTexts 文字数组，分行打印
     * @param srcImg 源图片
     * @param destImg 目标图片
     * @param fontName  字体名
     * @param fontStyle 字体样式
     * @param color     字体颜色
     * @param fontSize  字体大小
     * @param x         偏移量
     * @param y         偏移量
     * @param fontAdaptive 是否字体大小自适应
     * @param fontAdaptiveRatio  字体大小自适应比例。如果fontAdaptive=true，那么fontSize失效，实际fontsize=图片宽度*fontAdaptiveRatio
     * @param minFontSize 字体大小自适应的最小字体大小
     * @param stroke 是否描边
     * @param strokeSize 描边大小
     * @param strokeAdaptive 是否描边大小自适应。如果strokeAdaptivetrue，那么strokeSize失效，实际strokeSize=字体大小*strokeAdaptiveRatio
     * @param strokeAdaptiveRatio  描边大小自适应比率（相对于字体大小）
     * @param strokeColor 描边颜色
     */
    public static void pressText(String[] pressTexts, String srcImg, String destImg, String fontName, int fontStyle, Color color,
                                 int fontSize, int x, int y, boolean fontAdaptive, float fontAdaptiveRatio, Integer minFontSize,
                                 boolean stroke, float strokeSize, boolean strokeAdaptive, float strokeAdaptiveRatio, Color strokeColor) throws IOException {
        try(
                FileOutputStream out = new FileOutputStream(destImg);
        )
        {
            File imageFile = new File(srcImg);
            Image src = ImageIO.read(imageFile);
            int width = src.getWidth(null);
            int height = src.getHeight(null);
            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            Graphics2D g = image.createGraphics();
            g.drawImage(src, 0, 0, width, height, null);
            g.setColor(color);
            // 字体大小自适应
            if (fontAdaptive) {
                fontSize = (int) (width * fontAdaptiveRatio);
                // 最小自适应字体大小
                if (minFontSize != null && fontSize < minFontSize) {
                    fontSize = minFontSize;
                }
//                log.debug("width:" + width);
//                log.debug("fontAdaptiveRatio:" + fontAdaptiveRatio);
//                log.debug("实际fontSize：" + fontSize);
            }
            g.setFont(new Font(fontName, fontStyle, fontSize));
            for (int i = 0; i < pressTexts.length; i++) {
                if (stroke) {
                    // 描边处理
                    strokeSize = strokeAdaptive ? fontSize * strokeAdaptiveRatio : strokeSize;
                    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                    g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
                    g.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
                    FontRenderContext frc = g.getFontRenderContext();
                    TextLayout tl = new TextLayout(pressTexts[i], new Font(fontName, fontStyle, fontSize), frc);
                    // 文字坐标
                    Shape sha = tl.getOutline(AffineTransform.getTranslateInstance(x,y + fontSize * (i + 1)));
                    // 描边
                    g.setStroke(new BasicStroke(strokeSize));
                    // 描边颜色
                    g.setColor(strokeColor);
                    g.draw(sha);
                    g.setColor(color);
                    g.fill(sha);
                } else {
                    g.drawString(pressTexts[i], x, y + fontSize * (i + 1));
                }
            }

            g.dispose();

            // com.sun包不推荐使用，部分jdk版本可能不支持
//            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
//            encoder.encode(image);

            ImageIO.write(image, "jpg", out);
        }
    }



    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressText 文字
     * @param srcImg 源图片
     * @param destImg 目标图片
     * @param fontName  字体名
     * @param fontStyle 字体样式
     * @param color     字体颜色
     * @param fontSize  字体大小
     * @param x         偏移量
     * @param y         偏移量
     * @param fontAdaptive 是否字体自适应
     * @param fontAdaptiveRatio  字体自适应比例。如果fontAdaptive=true，那么fontSize失效，实际fontsize=图片宽度*fontAdaptiveRatio
     * @param minFontSize 字体大小自适应的最小字体大小
     */
    public static void pressText(String pressText, String srcImg, String destImg, String fontName, int fontStyle, Color color,
                                 int fontSize, int x, int y, boolean fontAdaptive, float fontAdaptiveRatio, Integer minFontSize) throws IOException {
        String[] texts = new String[1] ;
        texts[0] = pressText;
        pressText(texts, srcImg, destImg, fontName, fontStyle, color, fontSize, x, y, fontAdaptive, fontAdaptiveRatio,
                minFontSize, true, DEFAULT_STROKE_SIZE, true, DEFAULT_STROKE_ADAPTIVE_RATIO, DEFAULT_PRESS_TEXT_STROKE_COLOR);
    }





    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressText 文字
     * @param srcImg 源图片
     * @param destImg 目标图片
     * @param fontAdaptiveRatio  字体自适应比例。如果fontAdaptive=true，那么fontSize失效，实际fontsize=图片宽度*fontAdaptiveRatio
     * @param minFontSize 字体大小自适应的最小字体大小
     */
    public static void pressText(String pressText, String srcImg, String destImg, float fontAdaptiveRatio, Integer minFontSize) throws IOException {
        pressText(pressText, srcImg, destImg, DEFAULT_PRESS_TEXT_FONT_NAME, DEFAULT_PRESS_TEXT_FONT_TYPE,
                DEFAULT_PRESS_TEXT_FONT_COLOR, DEFAULT_PRESS_TEXT_FONT_SIZE, 0, 0, true, fontAdaptiveRatio, minFontSize);
    }

    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressText 文字
     * @param srcImg 源图片
     * @param destImg 目标图片
     * @param fontsize  字体大小
     */
    public static void pressText(String pressText, String srcImg, String destImg, int fontsize) throws IOException {
        pressText(pressText, srcImg, destImg, DEFAULT_PRESS_TEXT_FONT_NAME, DEFAULT_PRESS_TEXT_FONT_TYPE,
                DEFAULT_PRESS_TEXT_FONT_COLOR, fontsize, 0, 0, false, 0, null);
    }

    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressTexts 文字数组，分行打印
     * @param srcImg 源图片
     * @param destImg 目标图片
     * @param fontsize  字体大小
     */
    public static void pressText(String[] pressTexts, String srcImg, String destImg, int fontsize) throws IOException {
        pressText(pressTexts, srcImg, destImg, DEFAULT_PRESS_TEXT_FONT_NAME, DEFAULT_PRESS_TEXT_FONT_TYPE,
                DEFAULT_PRESS_TEXT_FONT_COLOR, fontsize, 0, 0, false, 0, null,
                true, DEFAULT_STROKE_SIZE, true, DEFAULT_STROKE_ADAPTIVE_RATIO, DEFAULT_PRESS_TEXT_STROKE_COLOR);
    }

    /**
     * 打印文字水印图片
     * <p>
     * 1.图标图片格式:png
     * 2.坐标轴:
     *    x轴决定左右位置
     *    y轴决定上下位置
     * 3.坐标位置
     *    x值越大距离右越近，反之,x值越小距离左越近;
     *    y值越大距离越往下，反之,y值越小距离越往上
     * </p>
     *
     * @param pressTexts 文字数组，分行打印
     * @param srcImg 源图片
     * @param destImg 目标图片
     * @param fontAdaptiveRatio  字体自适应比例。如果fontAdaptive=true，那么fontSize失效，实际fontsize=图片宽度*fontAdaptiveRatio
     * @param minFontSize 字体大小自适应的最小字体大小
     */
    public static void pressText(String[] pressTexts, String srcImg, String destImg, float fontAdaptiveRatio, Integer minFontSize) throws IOException {
        pressText(pressTexts, srcImg, destImg, DEFAULT_PRESS_TEXT_FONT_NAME, DEFAULT_PRESS_TEXT_FONT_TYPE,
                DEFAULT_PRESS_TEXT_FONT_COLOR, DEFAULT_PRESS_TEXT_FONT_SIZE, 0, 0, true,
                fontAdaptiveRatio, minFontSize, true, DEFAULT_STROKE_SIZE, true, DEFAULT_STROKE_ADAPTIVE_RATIO, DEFAULT_PRESS_TEXT_STROKE_COLOR);
    }



    /**
     * 获取压缩质量
     * @param qualityLevel 质量等级，具体见QUALITIES
     * @return
     */
    private static float getCompressQuality(int qualityLevel) {
        if (qualityLevel >= QUALITIES.length) {
            throw new RuntimeException("图片太大了,超出了压缩质量范围");
        }
        return QUALITIES[qualityLevel];
    }

    /**
     * 获取图片旋转类型
     * https://blog.csdn.net/ouyangtianhan/article/details/29825885 jpeg exif信息旋转类型说明
     * @return
     * @throws JpegProcessingException
     * @throws MetadataException
     */
    public static int getOrientationType(InputStream inputStream) throws JpegProcessingException, MetadataException, IOException {
        int orientationType = OrientationTypeEnum.ROTATE_NOMARL.getCode();
        Metadata metadata = JpegMetadataReader.readMetadata(inputStream);
        for (Directory directory : metadata.getDirectories()) {
            String oritentationDesc = directory.getString(ExifDirectoryBase.TAG_ORIENTATION);
            if (oritentationDesc != null) {
                System.out.println("oritentationDesc:" + oritentationDesc);
                for (Tag tag : directory.getTags()) {
                    System.out.println(tag.getDescription());
                }
                return directory.getInt(ExifDirectoryBase.TAG_ORIENTATION);
            }
        }
        return orientationType;
    }

    public static void main(String[] args) throws ImageProcessingException, IOException, MetadataException {

//        Metadata metadata = ImageMetadataReader.readMetadata(new File("C:/Users/Administrator/Desktop/signin/1.jpg"));
//        StringBuilder description = new StringBuilder();
//        metadata.getDirectories().forEach(directory -> {
//
//
//            directory.getTags().forEach(tag -> {
////                System.out.println(tag.getDescription());
//                if (tag.getTagType() == ExifDirectoryBase.TAG_ORIENTATION) {
//                    description.append(tag.getDescription());
//                }
//
//            });
//        });
//        System.out.println("desc:" + description);


//        for (int i = 0; i < 100; i++) {
//            String filename = "C:/Users/Administrator/Desktop/signin/" + i + ".jpg";
//            try (
//                    FileInputStream inputStream = new FileInputStream(filename);
//                    ) {
//                getOrientationType(inputStream);
//
//            }
////            getRotateAngle(URLUtil.getStream(new URL("https://img2.baidu.com/it/u=2961920357,2769635477&fm=26&fmt=auto")));
//        }
//        String filename = "C:/Users/Administrator/Desktop/exif.jpg";
//        try (
////                InputStream inputStream = URLUtil.getStream(new URL("http://7xt44n.com2.z0.glb.qiniucdn.com/exif.png"));
//                FileInputStream inputStream = new FileInputStream(filename);
//                    ) {
//            int orientationType = getOrientationType(inputStream);
//            System.out.println(orientationType);
//
//        }

        String[] srcImgs = {
                "C:/Users/Administrator/Desktop/f0bf7ff8-9cda-4300-ba9f-8e481bfd05aa.jpg",
                "C:/Users/Administrator/Desktop/temp/image/759fd44e-6460-42ef-8bbf-a32835800dea_a.jpeg",
                "C:/Users/Administrator/Desktop/414de5e2-9cdd-4393-9e03-8a74b09a7d97.jpg",
                "C:/Users/Administrator/Desktop/temp/image/1eb70013-1144-4880-982c-d6a2b3abb0e8_b.jpeg"
        };
        String destImg;
        String[] texts = {"驾校简称:温州货运驾校", "学员姓名:张三", "拍摄时间:2021-10-20 10:30:00"};
        long starttime = System.currentTimeMillis();
        for (int i = 0; i < 4; i++) {
            byte[] datas = IoUtil.readBytes(new FileInputStream(srcImgs[i]));
            destImg = "C:/Users/Administrator/Desktop/miaobian/miaobian_" + i + ".jpg";
            byte[] bytes = ImageUtil.pressText(texts, datas, 0.02f, 13);
            IoUtil.write(new FileOutputStream(destImg), true, bytes);
        }
        long endtime = System.currentTimeMillis();
        System.out.println("消耗时间：" + (endtime - starttime)/1000);


    }





}
